On the Conversion of Program Specifications into Pseudo Code using Jackson Structured Programming

In this paper, we present a technique to automatically translate program specifications into pseudo code. This technique is developed in the context of the well-known programming method Jackson Structured Programming (JSP). The objective of our research is to investigate to what extent a programming method can be automated. Current CASE tools are only able to automate programming methods to a very limited extent, whereas our technique automates the entire programming cycle by creating pseudo code from program specifications. We show that the JSP programming method can be transformed into a set of formal rules when the scope of the technique is limited to a well-defined area of problems. The rules are implemented in a CASE tool, called JSPTool, which is currently operative, although still in a prototyping phase. We believe that the strength of the CASE tool lies in the fact that it is able to automate the programming process completely, although its scope possibly is still rather limited. In this paper, the technique is explained by solving an example programming problem. The source language that has been developed to enter program specifications is briefly explained. Also, the differences between other JSP CASE tools and JSPTool are dealt with. Some additional features of the method are discussed and suggestions for future research are given

An Empirical Investigation into the Assimilation of Open Source Server Software

In recent years, open source software (OSS) has become widely known and adopted in practice. In academic literature, an increasing number of studies on the adoption of OSS have been published to investigate which factors influence its adoption. However, most of these studies have an exploratory nature, and empirical support based on a large-scale quantitative study is still missing. To address this issue, we present the results of a large-scale quantitative study investigating the factors that influence the assimilation of open source server software (OSSS) by organizations. OSSS refers to open source software products such as operating systems, web servers and mail servers. We developed a conceptual model that describes the factors influencing the assimilation of OSSS. We gathered data from 210 Belgian organizations and analyzed it using PLS to test this conceptual model. The proposed model was able to explain a large proportion of the variance in the dependent variable in the model. Surprisingly, we have found no support for the influence of several widely claimed advantages of OSSS. Our findings further show that the assimilation of OSSS is predominantly influenced by the availability of internal and external knowledge of OSSS

When Are Two Workflows the Same?

In the area of workflow management, one is confronted with a large number of competing languages and the relations between them (e.g. relative expressiveness) are usually not clear. Moreover, even within the same language it is generally possible to express the same workflow in different ways, a feature known as variability. This paper aims at providing some of the formal groundwork for studying relative expressiveness and variability by defining notions of equivalence capturing different views on how workflow systems operate. Firstly, a notion of observational equivalence in the absence of silent steps is defined and related to classical bisimulation. Secondly, a number of equivalence notions in the presence of silent steps are defined. A distinction is made between the case where silent steps are visible (but not controllable) by the environment and the case where silent steps are not visible, i.e., there is an alternation between system events and environment interactions. It is shown that these notions of equivalence are different and do not coincide with classical notions of bisimulation with silent steps (e.g. weak and branching)

Enabling Normalized Systems in Practice – Exploring a Modeling Approach

Contemporary organizations are required to adapt to a changing environment in an agile way, which is often deemed very challenging. Normalized Systems (NS) theory attempts to build highly evolvable software systems by using systems theory as its theoretical underpinning. A modeling method which supports the identification of the NS elements, required for building NS sofware in practice, is currently missing. Therefore, the paper introduces an approach for creating both data models and processing models in the context of NS, as well as their integration. It is discussed how these models can be taken as the input for the actual creation of evolutionary prototypes by using an earlier developed supporting tool. The modeling approach and its suitability for feeding the tool are evaluated to discover their current strengths and weaknesses